

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
    <style>
    /* base */
    html,
    body,
    .container {
      width: 100%;
      height: 100%;
    }

    a,
    a:link,
    a:visited {
      text-decoration: none;
      color: inherit;
    }

    ul {
      list-style: none;
    }

    *,
    ::before,
    ::after {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
    }

    *:focus {
      outline: 0;
    }

    .container {
      display: flex;
      padding-top: 20px;
    }

    /* Nav */
    .container .doc-nav {
      position: fixed;
      height: 100%;
      margin: 0 30px 0 40px;
      width: 280px;
    }

    .doc-nav .nav-header {
      display: flex;
      align-items: center;
      box-sizing: border-box;
      background-color: rgb(240, 241, 242);
      height: 40px;
      padding: 16px;
      font-size: 18px;
      font-weight: 500;
      color: rgb(62, 64, 66);
      cursor: pointer;
    }

    .doc-nav .nav-content {
      height: calc(100% - 40px);
      overflow-y: auto;
      color: rgb(32, 34, 36);
    }

    .doc-nav .nav-content .nav-list,
    .doc-nav .nav-content .nav-sub-list {
      line-height: 1.5rem;
    }

    .doc-nav .nav-content .nav-label {
      display: inline-block;
      position: relative;
      padding: 2px 0 2px 20px;
      margin-bottom: 4px;
    }

    .doc-nav .nav-content .nav-sub-label {
      position: relative;
      padding: 2px 0 2px 40px;
      font-size: 14px;
    }

    .doc-nav .nav-content .nav-sub-label:hover {
      text-decoration: underline;
    }

    .doc-nav .nav-content .nav-list .nav-label.group::before {
      border-bottom: 0.25rem solid transparent;
      border-left: 0.25rem solid #6e7072;
      border-right: 0;
      border-top: 0.25rem solid transparent;
      content: '';
      display: block;
      height: 0;
      left: 0.5rem;
      position: absolute;
      top: 0.625rem;
      transition: transform 0.1s linear;
      width: 0;
    }

    .doc-nav .nav-content .nav-list .nav-label.group.active::before {
      transform: rotate(90deg);
    }

    /* doc content */
    .container .doc-content {
      position: fixed;
      height: 100%;
      width: calc(100% - 80px - 40px - 30px - 240px);
      right: 0%;
      overflow-y: auto;
    }

    .doc-title {
      border-bottom: 1px solid #dcdee0;
      font-size: 22px;
      margin: 8px 0 0;
      padding-bottom: 16px;
    }

    .doc-content h3 {
      font-size: 24px;
      font-weight: 600;
      margin: 24px 0;
    }

    .doc-content h4 {
      font-size: 22px;
      font-weight: 500;
      margin: 30px 0 8px;
    }

    .doc-content h4 span {
      color: #007d9c;
    }

    .doc-content .doc-declare {
      background-color: #fafafa;
      border-radius: 5px;
      border: 1px solid #ccc;
      font-size: 14px;
      overflow-x: auto;
      padding: 10px;
      tab-size: 4;
      line-height: 20px;
    }

    .doc-content .doc-comment {
      font-size: 16px;
      margin: 16px 0;
      line-height: 24px;
      word-break: break-word;
    }
  </style>

</head>
<body>
  <div class="container">
    <div class="doc-nav">
      <a href="#Documentation" class="nav-header">Documentation</a>
      <nav class="nav-content">
        <ul class="nav-list">
          <li>
            <a href="#includes" class="nav-label">Includes</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#config.h" class="nav-sub-label">config.h</a>
              </li>
      

              <li>
                <a href="#MBEDTLS_CONFIG_FILE" class="nav-sub-label">MBEDTLS_CONFIG_FILE</a>
              </li>
      

              <li>
                <a href="#poly1305.h" class="nav-sub-label">poly1305.h</a>
              </li>
      

              <li>
                <a href="#chacha20.h" class="nav-sub-label">chacha20.h</a>
              </li>
      

              <li>
                <a href="#chachapoly_alt.h" class="nav-sub-label">chachapoly_alt.h</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#macros" class="nav-label">Macros</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#MBEDTLS_CHACHAPOLY_H" class="nav-sub-label">MBEDTLS_CHACHAPOLY_H</a>
              </li>
      

              <li>
                <a href="#MBEDTLS_ERR_CHACHAPOLY_BAD_STATE" class="nav-sub-label">MBEDTLS_ERR_CHACHAPOLY_BAD_STATE</a>
              </li>
      

              <li>
                <a href="#MBEDTLS_ERR_CHACHAPOLY_AUTH_FAILED" class="nav-sub-label">MBEDTLS_ERR_CHACHAPOLY_AUTH_FAILED</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#functions" class="nav-label">Functions</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#mbedtls_chachapoly_init" class="nav-sub-label">mbedtls_chachapoly_init</a>
              </li>
      

              <li>
                <a href="#mbedtls_chachapoly_free" class="nav-sub-label">mbedtls_chachapoly_free</a>
              </li>
      

              <li>
                <a href="#mbedtls_chachapoly_setkey" class="nav-sub-label">mbedtls_chachapoly_setkey</a>
              </li>
      

              <li>
                <a href="#mbedtls_chachapoly_starts" class="nav-sub-label">mbedtls_chachapoly_starts</a>
              </li>
      

              <li>
                <a href="#mbedtls_chachapoly_update_aad" class="nav-sub-label">mbedtls_chachapoly_update_aad</a>
              </li>
      

              <li>
                <a href="#mbedtls_chachapoly_update" class="nav-sub-label">mbedtls_chachapoly_update</a>
              </li>
      

              <li>
                <a href="#mbedtls_chachapoly_finish" class="nav-sub-label">mbedtls_chachapoly_finish</a>
              </li>
      

              <li>
                <a href="#mbedtls_chachapoly_encrypt_and_tag" class="nav-sub-label">mbedtls_chachapoly_encrypt_and_tag</a>
              </li>
      

              <li>
                <a href="#mbedtls_chachapoly_auth_decrypt" class="nav-sub-label">mbedtls_chachapoly_auth_decrypt</a>
              </li>
      

              <li>
                <a href="#mbedtls_chachapoly_self_test" class="nav-sub-label">mbedtls_chachapoly_self_test</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#vars" class="nav-label">Vars</a>
            
            <ul class="nav-sub-list">
            
            </ul>
            
          </li>
          <li>
            <a href="#consts" class="nav-label">Consts</a>
            
            <ul class="nav-sub-list">
            
            </ul>
            
          </li>
          <li>
            <a href="#types" class="nav-label">Types</a>
            
            <ul class="nav-sub-list">
            
            </ul>
            
          </li>
          <li>
            <a href="#typedefs" class="nav-label">Typedefs</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#
mbedtls_chachapoly_mode_t;
" class="nav-sub-label">
mbedtls_chachapoly_mode_t;
</a>
              </li>
      

              <li>
                <a href="#
mbedtls_chachapoly_context;
" class="nav-sub-label">
mbedtls_chachapoly_context;
</a>
              </li>
      
            </ul>
            
          </li>
        </ul>
      </nav>
    </div>
    <div class="doc-content">
      <h2 id="Documentation" class="doc-title">Documentation</h2>
      <h3 id="includes">Includes</h3>
      

      <h4 id="config.h"><span>config.h</span></h4>
      <pre class="doc-declare"><code>#include "config.h"
</code></pre>
      <pre class="doc-comment">#include "config.h"
</pre>

      <h4 id="MBEDTLS_CONFIG_FILE"><span>MBEDTLS_CONFIG_FILE</span></h4>
      <pre class="doc-declare"><code>#include MBEDTLS_CONFIG_FILE
</code></pre>
      <pre class="doc-comment">#include MBEDTLS_CONFIG_FILE
</pre>

      <h4 id="poly1305.h"><span>poly1305.h</span></h4>
      <pre class="doc-declare"><code>#include "poly1305.h"
</code></pre>
      <pre class="doc-comment">#include "poly1305.h"
</pre>

      <h4 id="chacha20.h"><span>chacha20.h</span></h4>
      <pre class="doc-declare"><code>#include "chacha20.h"
</code></pre>
      <pre class="doc-comment">#include "chacha20.h"
</pre>

      <h4 id="chachapoly_alt.h"><span>chachapoly_alt.h</span></h4>
      <pre class="doc-declare"><code>#include "chachapoly_alt.h"
</code></pre>
      <pre class="doc-comment">#include "chachapoly_alt.h"
</pre>
      <h3 id="macros">Macros</h3>
      

      <h4 id="MBEDTLS_CHACHAPOLY_H">Marco <span>MBEDTLS_CHACHAPOLY_H</span></h4>
      <pre class="doc-declare"><code>#define MBEDTLS_CHACHAPOLY_H
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="MBEDTLS_ERR_CHACHAPOLY_BAD_STATE">Marco <span>MBEDTLS_ERR_CHACHAPOLY_BAD_STATE</span></h4>
      <pre class="doc-declare"><code>#define MBEDTLS_ERR_CHACHAPOLY_BAD_STATE           -84 /**< The requested operation is not permitted in the current state. */
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="MBEDTLS_ERR_CHACHAPOLY_AUTH_FAILED">Marco <span>MBEDTLS_ERR_CHACHAPOLY_AUTH_FAILED</span></h4>
      <pre class="doc-declare"><code>#define MBEDTLS_ERR_CHACHAPOLY_AUTH_FAILED         -86 /**< Authenticated decryption failed: data was not authentic. */
</code></pre>
      <pre class="doc-comment"></pre>
      <h3 id="functions">Functions</h3>
      

      <h4 id="mbedtls_chachapoly_init">Func <span>mbedtls_chachapoly_init</span></h4>
      <pre class="doc-declare"><code>void mbedtls_chachapoly_init( mbedtls_chachapoly_context *ctx );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function initializes the specified ChaCha20-Poly1305 context.
 *
 *                  It must be the first API called before using
 *                  the context. It must be followed by a call to
 *                  \c mbedtls_chachapoly_setkey() before any operation can be
 *                  done, and to \c mbedtls_chachapoly_free() once all
 *                  operations with that context have been finished.
 *
 *                  In order to encrypt or decrypt full messages at once, for
 *                  each message you should make a single call to
 *                  \c mbedtls_chachapoly_crypt_and_tag() or
 *                  \c mbedtls_chachapoly_auth_decrypt().
 *
 *                  In order to encrypt messages piecewise, for each
 *                  message you should make a call to
 *                  \c mbedtls_chachapoly_starts(), then 0 or more calls to
 *                  \c mbedtls_chachapoly_update_aad(), then 0 or more calls to
 *                  \c mbedtls_chachapoly_update(), then one call to
 *                  \c mbedtls_chachapoly_finish().
 *
 * \warning         Decryption with the piecewise API is discouraged! Always
 *                  use \c mbedtls_chachapoly_auth_decrypt() when possible!
 *
 *                  If however this is not possible because the data is too
 *                  large to fit in memory, you need to:
 *
 *                  - call \c mbedtls_chachapoly_starts() and (if needed)
 *                  \c mbedtls_chachapoly_update_aad() as above,
 *                  - call \c mbedtls_chachapoly_update() multiple times and
 *                  ensure its output (the plaintext) is NOT used in any other
 *                  way than placing it in temporary storage at this point,
 *                  - call \c mbedtls_chachapoly_finish() to compute the
 *                  authentication tag and compared it in constant time to the
 *                  tag received with the ciphertext.
 *
 *                  If the tags are not equal, you must immediately discard
 *                  all previous outputs of \c mbedtls_chachapoly_update(),
 *                  otherwise you can now safely use the plaintext.
 *
 * \param ctx       The ChachaPoly context to initialize. Must not be \c NULL.
 */</pre>

      <h4 id="mbedtls_chachapoly_free">Func <span>mbedtls_chachapoly_free</span></h4>
      <pre class="doc-declare"><code>void mbedtls_chachapoly_free( mbedtls_chachapoly_context *ctx );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function releases and clears the specified
 *                  ChaCha20-Poly1305 context.
 *
 * \param ctx       The ChachaPoly context to clear. This may be \c NULL, in which
 *                  case this function is a no-op.
 */</pre>

      <h4 id="mbedtls_chachapoly_setkey">Func <span>mbedtls_chachapoly_setkey</span></h4>
      <pre class="doc-declare"><code>int mbedtls_chachapoly_setkey( mbedtls_chachapoly_context *ctx,
                              const unsigned char key[32] );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function sets the ChaCha20-Poly1305
 *                  symmetric encryption key.
 *
 * \param ctx       The ChaCha20-Poly1305 context to which the key should be
 *                  bound. This must be initialized.
 * \param key       The \c 256 Bit (\c 32 Bytes) key.
 *
 * \return          \c 0 on success.
 * \return          A negative error code on failure.
 */</pre>

      <h4 id="mbedtls_chachapoly_starts">Func <span>mbedtls_chachapoly_starts</span></h4>
      <pre class="doc-declare"><code>int mbedtls_chachapoly_starts( mbedtls_chachapoly_context *ctx,
                              const unsigned char nonce[12],
                              mbedtls_chachapoly_mode_t mode );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function starts a ChaCha20-Poly1305 encryption or
 *                  decryption operation.
 *
 * \warning         You must never use the same nonce twice with the same key.
 *                  This would void any confidentiality and authenticity
 *                  guarantees for the messages encrypted with the same nonce
 *                  and key.
 *
 * \note            If the context is being used for AAD only (no data to
 *                  encrypt or decrypt) then \p mode can be set to any value.
 *
 * \warning         Decryption with the piecewise API is discouraged, see the
 *                  warning on \c mbedtls_chachapoly_init().
 *
 * \param ctx       The ChaCha20-Poly1305 context. This must be initialized
 *                  and bound to a key.
 * \param nonce     The nonce/IV to use for the message.
 *                  This must be a redable buffer of length \c 12 Bytes.
 * \param mode      The operation to perform: #MBEDTLS_CHACHAPOLY_ENCRYPT or
 *                  #MBEDTLS_CHACHAPOLY_DECRYPT (discouraged, see warning).
 *
 * \return          \c 0 on success.
 * \return          A negative error code on failure.
 */</pre>

      <h4 id="mbedtls_chachapoly_update_aad">Func <span>mbedtls_chachapoly_update_aad</span></h4>
      <pre class="doc-declare"><code>int mbedtls_chachapoly_update_aad( mbedtls_chachapoly_context *ctx,
                                  const unsigned char *aad,
                                  size_t aad_len );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function feeds additional data to be authenticated
 *                  into an ongoing ChaCha20-Poly1305 operation.
 *
 *                  The Additional Authenticated Data (AAD), also called
 *                  Associated Data (AD) is only authenticated but not
 *                  encrypted nor included in the encrypted output. It is
 *                  usually transmitted separately from the ciphertext or
 *                  computed locally by each party.
 *
 * \note            This function is called before data is encrypted/decrypted.
 *                  I.e. call this function to process the AAD before calling
 *                  \c mbedtls_chachapoly_update().
 *
 *                  You may call this function multiple times to process
 *                  an arbitrary amount of AAD. It is permitted to call
 *                  this function 0 times, if no AAD is used.
 *
 *                  This function cannot be called any more if data has
 *                  been processed by \c mbedtls_chachapoly_update(),
 *                  or if the context has been finished.
 *
 * \warning         Decryption with the piecewise API is discouraged, see the
 *                  warning on \c mbedtls_chachapoly_init().
 *
 * \param ctx       The ChaCha20-Poly1305 context. This must be initialized
 *                  and bound to a key.
 * \param aad_len   The length in Bytes of the AAD. The length has no
 *                  restrictions.
 * \param aad       Buffer containing the AAD.
 *                  This pointer can be \c NULL if `aad_len == 0`.
 *
 * \return          \c 0 on success.
 * \return          #MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA
 *                  if \p ctx or \p aad are NULL.
 * \return          #MBEDTLS_ERR_CHACHAPOLY_BAD_STATE
 *                  if the operations has not been started or has been
 *                  finished, or if the AAD has been finished.
 */</pre>

      <h4 id="mbedtls_chachapoly_update">Func <span>mbedtls_chachapoly_update</span></h4>
      <pre class="doc-declare"><code>int mbedtls_chachapoly_update( mbedtls_chachapoly_context *ctx,
                              size_t len,
                              const unsigned char *input,
                              unsigned char *output );</code></pre>
      <pre class="doc-comment">/**
 * \brief           Thus function feeds data to be encrypted or decrypted
 *                  into an on-going ChaCha20-Poly1305
 *                  operation.
 *
 *                  The direction (encryption or decryption) depends on the
 *                  mode that was given when calling
 *                  \c mbedtls_chachapoly_starts().
 *
 *                  You may call this function multiple times to process
 *                  an arbitrary amount of data. It is permitted to call
 *                  this function 0 times, if no data is to be encrypted
 *                  or decrypted.
 *
 * \warning         Decryption with the piecewise API is discouraged, see the
 *                  warning on \c mbedtls_chachapoly_init().
 *
 * \param ctx       The ChaCha20-Poly1305 context to use. This must be initialized.
 * \param len       The length (in bytes) of the data to encrypt or decrypt.
 * \param input     The buffer containing the data to encrypt or decrypt.
 *                  This pointer can be \c NULL if `len == 0`.
 * \param output    The buffer to where the encrypted or decrypted data is
 *                  written. This must be able to hold \p len bytes.
 *                  This pointer can be \c NULL if `len == 0`.
 *
 * \return          \c 0 on success.
 * \return          #MBEDTLS_ERR_CHACHAPOLY_BAD_STATE
 *                  if the operation has not been started or has been
 *                  finished.
 * \return          Another negative error code on other kinds of failure.
 */</pre>

      <h4 id="mbedtls_chachapoly_finish">Func <span>mbedtls_chachapoly_finish</span></h4>
      <pre class="doc-declare"><code>int mbedtls_chachapoly_finish( mbedtls_chachapoly_context *ctx,
                              unsigned char mac[16] );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function finished the ChaCha20-Poly1305 operation and
 *                  generates the MAC (authentication tag).
 *
 * \param ctx       The ChaCha20-Poly1305 context to use. This must be initialized.
 * \param mac       The buffer to where the 128-bit (16 bytes) MAC is written.
 *
 * \warning         Decryption with the piecewise API is discouraged, see the
 *                  warning on \c mbedtls_chachapoly_init().
 *
 * \return          \c 0 on success.
 * \return          #MBEDTLS_ERR_CHACHAPOLY_BAD_STATE
 *                  if the operation has not been started or has been
 *                  finished.
 * \return          Another negative error code on other kinds of failure.
 */</pre>

      <h4 id="mbedtls_chachapoly_encrypt_and_tag">Func <span>mbedtls_chachapoly_encrypt_and_tag</span></h4>
      <pre class="doc-declare"><code>int mbedtls_chachapoly_encrypt_and_tag( mbedtls_chachapoly_context *ctx,
                                       size_t length,
                                       const unsigned char nonce[12],
                                       const unsigned char *aad,
                                       size_t aad_len,
                                       const unsigned char *input,
                                       unsigned char *output,
                                       unsigned char tag[16] );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function performs a complete ChaCha20-Poly1305
 *                  authenticated encryption with the previously-set key.
 *
 * \note            Before using this function, you must set the key with
 *                  \c mbedtls_chachapoly_setkey().
 *
 * \warning         You must never use the same nonce twice with the same key.
 *                  This would void any confidentiality and authenticity
 *                  guarantees for the messages encrypted with the same nonce
 *                  and key.
 *
 * \param ctx       The ChaCha20-Poly1305 context to use (holds the key).
 *                  This must be initialized.
 * \param length    The length (in bytes) of the data to encrypt or decrypt.
 * \param nonce     The 96-bit (12 bytes) nonce/IV to use.
 * \param aad       The buffer containing the additional authenticated
 *                  data (AAD). This pointer can be \c NULL if `aad_len == 0`.
 * \param aad_len   The length (in bytes) of the AAD data to process.
 * \param input     The buffer containing the data to encrypt or decrypt.
 *                  This pointer can be \c NULL if `ilen == 0`.
 * \param output    The buffer to where the encrypted or decrypted data
 *                  is written. This pointer can be \c NULL if `ilen == 0`.
 * \param tag       The buffer to where the computed 128-bit (16 bytes) MAC
 *                  is written. This must not be \c NULL.
 *
 * \return          \c 0 on success.
 * \return          A negative error code on failure.
 */</pre>

      <h4 id="mbedtls_chachapoly_auth_decrypt">Func <span>mbedtls_chachapoly_auth_decrypt</span></h4>
      <pre class="doc-declare"><code>int mbedtls_chachapoly_auth_decrypt( mbedtls_chachapoly_context *ctx,
                                    size_t length,
                                    const unsigned char nonce[12],
                                    const unsigned char *aad,
                                    size_t aad_len,
                                    const unsigned char tag[16],
                                    const unsigned char *input,
                                    unsigned char *output );</code></pre>
      <pre class="doc-comment">/**
 * \brief           This function performs a complete ChaCha20-Poly1305
 *                  authenticated decryption with the previously-set key.
 *
 * \note            Before using this function, you must set the key with
 *                  \c mbedtls_chachapoly_setkey().
 *
 * \param ctx       The ChaCha20-Poly1305 context to use (holds the key).
 * \param length    The length (in Bytes) of the data to decrypt.
 * \param nonce     The \c 96 Bit (\c 12 bytes) nonce/IV to use.
 * \param aad       The buffer containing the additional authenticated data (AAD).
 *                  This pointer can be \c NULL if `aad_len == 0`.
 * \param aad_len   The length (in bytes) of the AAD data to process.
 * \param tag       The buffer holding the authentication tag.
 *                  This must be a readable buffer of length \c 16 Bytes.
 * \param input     The buffer containing the data to decrypt.
 *                  This pointer can be \c NULL if `ilen == 0`.
 * \param output    The buffer to where the decrypted data is written.
 *                  This pointer can be \c NULL if `ilen == 0`.
 *
 * \return          \c 0 on success.
 * \return          #MBEDTLS_ERR_CHACHAPOLY_AUTH_FAILED
 *                  if the data was not authentic.
 * \return          Another negative error code on other kinds of failure.
 */</pre>

      <h4 id="mbedtls_chachapoly_self_test">Func <span>mbedtls_chachapoly_self_test</span></h4>
      <pre class="doc-declare"><code>int mbedtls_chachapoly_self_test( int verbose );</code></pre>
      <pre class="doc-comment">/**
 * \brief           The ChaCha20-Poly1305 checkup routine.
 *
 * \return          \c 0 on success.
 * \return          \c 1 on failure.
 */</pre>
      <h3 id="vars">Vars</h3>
      
      <h3 id="consts">Consts</h3>
      
      <h3 id="types">Types</h3>
      
      <h3 id="typedefs">Typedefs</h3>
      

      <h4 id="
mbedtls_chachapoly_mode_t;
">Typedef <span>
mbedtls_chachapoly_mode_t;
</span></h4>
      <pre class="doc-declare"><code>typedef enum
{
   MBEDTLS_CHACHAPOLY_ENCRYPT,    /**< The mode value for performing encryption. */
   MBEDTLS_CHACHAPOLY_DECRYPT     /**< The mode value for performing decryption. */
}
mbedtls_chachapoly_mode_t;
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="
mbedtls_chachapoly_context;
">Typedef <span>
mbedtls_chachapoly_context;
</span></h4>
      <pre class="doc-declare"><code>typedef struct mbedtls_chachapoly_context
{
   mbedtls_chacha20_context chacha20_ctx; /**< The ChaCha20 context. */
   mbedtls_poly1305_context poly1305_ctx; /**< The Poly1305 context. */
   uint64_t aad_len;                      /**< The length (bytes) of the Additional Authenticated Data. */
   uint64_t ciphertext_len;               /**< The length (bytes) of the ciphertext. */
   int state;                             /**< The current state of the context. */
   mbedtls_chachapoly_mode_t mode;        /**< Cipher mode (encrypt or decrypt). */
}
mbedtls_chachapoly_context;
</code></pre>
      <pre class="doc-comment"></pre>
    </div>
  </body>
</html>
            